SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Procedural parameter</title>

</head>

Procedural parameter

</h1>

</header>

<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="en" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">In <a href="Computing" title="Computing">computing</a>, a procedural parameter is a <a href="Parameter_(computer_science)" class="mw-redirect" title="Parameter (computer science)">parameter</a> of a <a href="Subroutine" class="mw-redirect" title="Subroutine">procedure</a> that is itself a procedure.

This concept is an extremely powerful and versatile <a href="Computer_programming" title="Computer programming">programming</a> tool, because it allows programmers to modify certain steps of a <a href="Library_(computer_science)" class="mw-redirect" title="Library (computer science)">library procedure</a> in arbitrarily complicated ways, without having to understand or modify the code of that procedure.

This tool is particularly effective and convenient in languages that support <a href="Nested_function" title="Nested function">local function definitions</a>, such as <a href="Pascal_programming_language" class="mw-redirect" title="Pascal programming language">Pascal</a> and the modern <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU dialect</a> of <a href="C_(programming_language)" title="C (programming language)">C</a>. It is even more so when <a href="Closure_(computer_science)" class="mw-redirect" title="Closure (computer science)">function closures</a> are available. The same functionality (and more) is provided by <a href="Object_(computing)" class="mw-redirect" title="Object (computing)">objects</a> in <a href="Object_oriented_programming" class="mw-redirect" title="Object oriented programming">object oriented</a> <a href="Programming_language" title="Programming language">programming languages</a>, but at a significantly higher cost.

Procedural parameters are somewhat related to the concepts of <a href="First-class_function" title="First-class function">first-class function</a> and <a href="Anonymous_function" title="Anonymous function">anonymous function</a>, but is distinct from them. These two concepts have more to do with how functions are defined, rather than how they are used.

<div class="mw-heading mw-heading2"><h2 id="Basic_concept">Basic concept</h2></div>

In most languages that provide this feature, a procedural parameter f of a subroutine P can be called inside the body of P as if it were an ordinary procedure:

<pre>procedure P(f):

return f(6,3) * f(2,1)

</pre>

When calling the subroutine P, one must give it one argument, that must be some previously defined function compatible with the way P uses its parameter f. For example, if we define

<pre>procedure plus(x, y):

return x + y

</pre>

then we may call P (plus), and the result will be plus(6,3) * plus(2,1) = (6 + 3)*(2 + 1) = 27. On the other hand, if we define

<pre>procedure quot(u, v):

return u/v

</pre>

then the call P (quot) will return quot(6,3)*quot(2,1) = (6/3)*(2/1) = 4. Finally, if we define

<pre>procedure evil(z)

return z + 100

</pre>

then the call P (evil) will not make much sense, and may be flagged as an error.

<div class="mw-heading mw-heading3"><h3 id="Syntactic_details">Syntactic details</h3></div>

Some programming languages that have this feature may allow or require a complete type declaration for each procedural parameter f, including the number and type of its arguments, and the type of its result, if any. For example, in the C programming language the example above could be written as

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>int P(int (*f)(int a, int b)) {

return f(6,3) * f(2,1);

}

</pre></div>

In principle, the actual function actf that is passed as argument when P is called must be type-compatible with the declared type of the procedure parameter f. This usually means that actf and f must return the same type of result, must have the same number of arguments, and corresponding arguments must have the same type. The names of the arguments need not be the same, however, as shown by the plus and quot examples above. However, some programming languages may be more restrictive or more liberal in this regard.

<div class="mw-heading mw-heading3"><h3 id="Scoping">Scoping</h3></div>

In languages that allow procedural parameters, the scoping rules are usually defined in such a way that procedural parameters are executed in their native scope. More precisely, suppose that the function actf is passed as argument to P, as its procedural parameter f; and f is then called from inside the body of P. While actf is being executed, it sees the environment of its definition.

The implementation of these scoping rules is not trivial. By the time that actf is finally executed, the <a href="Call_stack#Structure" title="Call stack">activation records</a> where its environment variables live may be arbitrarily deep in the stack. This is the so-called <a href="Funarg_problem#Downwards_funarg_problem" title="Funarg problem">downwards funarg problem</a>.

<div class="mw-heading mw-heading2"><h2 id="Example:_Generic_insertion_sort">Example: Generic insertion sort</h2></div>

The concept of procedural parameter is best explained by examples. A typical application is the following generic implementation of the <a href="Insertion_sort" title="Insertion sort">insertion sort</a> algorithm, that takes two integer parameters a,b and two procedural parameters prec, swap:

<pre>procedure isort(a, b, prec, swap):

integer i, j;

i ← a;

while i ≤ b do

j ← i;

while j > a and prec(j, j−1) do

swap(j, j−1);

j ← j−1;

i ← i+1;

</pre>

This procedure can be used to sort the elements x[a] through x[b] of some array x, of arbitrary <a href="Datatype" class="mw-redirect" title="Datatype">type</a>, in a user-specified order. The parameters prec and swap should be two <a href="Function_(computing)" class="mw-redirect" title="Function (computing)">functions</a>, defined by the client, both taking two integers r, s between a and b. The prec function should return true <a href="If_and_only_if" title="If and only if">if and only if</a> the data stored in x[r] should precede the data stored in x[s], in the ordering defined by the client. The swap function should exchange the contents of x[r] and x[s], and return no result.

By the proper choice of the functions prec and swap, the same isort procedure can be used to reorder arrays of any data type, stored in any medium and organized in any <a href="Data_structure" title="Data structure">data structure</a> that provides indexed access to individual array elements. (Note however that there are <a href="Sorting_algorithm" title="Sorting algorithm">sorting algorithms</a> that are much more efficient than insertion sort for large arrays.)

<div class="mw-heading mw-heading3"><h3 id="Sorting_floating-point_numbers">Sorting floating-point numbers</h3></div>

For instance, we can sort an array z of 20 floating-point numbers, z[1] through z[20] in increasing order by calling isort (1, 20,zprec,zswap), where the functions zprec and zswap are defined as

<pre>procedure zprec(r, s):

return (z[r] < z[s]);

procedure zswap(r, s):

float t;

t ← z[r];

z[r] ← z[s];

z[s] ← t

</pre>

<div class="mw-heading mw-heading3"><h3 id="Sorting_rows_of_a_matrix">Sorting rows of a matrix</h3></div>

For another example, let M be a matrix of integers with 10 rows and 20 columns, with indices starting at 1. The following code will rearrange the elements in each row so that all the even values come before all odd values:

<pre>integer i

procedure eoprec(r, s):

return (M[i, r] mod 2) < (M[i, s] mod 2);

procedure eoswap(r, s):

integer t;

t ← M[i,r];

M[i,r] ← M[i,s];

M[i,s] ← t;

for i from 1 to 10 do

isort(1, 20, eoprec, eoswap);

</pre>

Note that the effects of eoprec and eoswap depend on the row number i, but the isort procedure does not need to know that.

<div class="mw-heading mw-heading3"><h3 id="Vector-sorting_procedure">Vector-sorting procedure</h3></div>

The following example uses isort to define a procedure vecsort that takes an integer n and an integer vector v with elements v[0] through v[n−1] and sorts them in either increasing or decreasing order, depending on whether a third parameter incr is true or false, respectively:

<pre>procedure vecsort(n, v, incr):

procedure vprec(r, s):

if incr then

return v[r] < v[s];

else

return v[r] > v[s];

procedure vswap(r, s):

integer t;

t ← v[r];

v[r] ← v[s];

v[s] ← t

isort(0, n−1, vprec, vswap);

</pre>

Note the use of nested function definitions to get a function vprec whose effect depends on the parameter incr passed to vecsort. In languages that do not allow nested function definitions, like standard C, obtaining this effect would require rather complicated and/or <a href="Thread_safety" title="Thread safety">thread-unsafe</a> code.

<div class="mw-heading mw-heading2"><h2 id="Example:_merging_two_sequences">Example: merging two sequences</h2></div>

The following example illustrates the use of procedural parameters to process abstract data structures independently of their concrete implementation. The problem is to merge two ordered sequences of records into a single sorted sequence, where the nature of the records and the ordering criterion can be chosen by the client. The following implementation assumes only that each record can be referenced by a <a href="Memory_address" title="Memory address">memory address</a>, and there is a "null address" Λ that is not the address of any valid record. The client must provide the addresses A, B of the first records in each sequence, and functions prec, next, and append, to be described later.

<pre>procedure merge(A, B, prec, nextA, appendA, nextB, appendB):

address ini, fin, t

ini ← Λ; fin ← Λ

while A ≠ Λ or B ≠ Λ do

if B = Λ or (A ≠ Λ and B ≠ Λ and prec(A, B)) then

t ← nextA(A)

fin ← appendA(A, fin); if ini = Λ then ini ← fin

A ← t

else

t ← nextB(B)

fin ← appendB(B, fin); if ini = Λ then ini ← fin

B ← t

return ini

</pre>

The function prec should take the addresses r, s of two records, one from each sequence, and return true if the first record should come before the other in the output sequence. The function nextA should take the address of a record from the first sequence, and return the address of the next record in the same sequence, or Λ if there is none. The function appendA should append the first record from sequence A to the output sequence; its arguments are the address A of the record to be appended, and the address fin of the last record of the output list (or Λ if that list is still empty). The procedure appendA should return the updated address of the final element of the output list. The procedures nextB and appendB are analogous for the other input sequence.

<div class="mw-heading mw-heading3"><h3 id="Merging_linked_lists">Merging linked lists</h3></div>

To illustrate the use of the generic merge procedure, here is the code for merging two simple <a href="Linked_list" title="Linked list">linked lists</a>, starting with nodes at addresses R, S. Here we assume that each record x contains an integer field x.INFO and an address field x.NEXT that points to the next node; where the info fields are in increasing order in each list. The input lists are dismantled by the merge, and their nodes are used to build the output list.

<pre>procedure listmerge(R, S):

procedure prec(r, s):

return r.INFO < s.INFO

procedure next(x):

return x.NEXT

procedure append(x, fin)

if fin ≠ Λ then fin.NEXT ← x

x.NEXT ← Λ

return x

return merge(R, S, prec, next, append, next, append)

</pre>

<div class="mw-heading mw-heading3"><h3 id="Merging_vectors">Merging vectors</h3></div>

The following code illustrates the independence of the generic merge procedure from the actual representation of the sequences. It merges the elements of two ordinary arrays U[0] through U[m−1] and V[0] through V[n−1] of floating-point numbers, in decreasing order. The input arrays are not modified, and the merged sequence of values is stored into a third vector W[0] through W[m+n−1]. As in the C programming language, we assume that the expression "&V" yields the address of variable V, "*p" yields the variable whose address is the value of p, and that "&(X[i])" is equivalent to "&(X[0]) + i" for any array X and any integer i.

<pre>procedure arraymerge(U, m, V, n, W):

procedure prec(r, s):

return (*r) > (*s)

procedure nextU(x):

if x = &(U[m−1]) then return Λ else return x + 1

procedure nextV(x):

if x = &(V[n−1]) then return Λ else return x + 1

procedure append(x, fin)

if fin = Λ then fin ← &(W[0])

(*fin) ← (*x)

return fin + 1

if m = 0 then U ← Λ

if n = 0 then V ← Λ

return merge(U, V, prec, nextU, append, nextV, append)

</pre>

<div class="mw-heading mw-heading2"><h2 id="Example:_Definite_integral">Example: Definite integral</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Integrating_over_an_interval">Integrating over an interval</h3></div>

The following procedure computes the approximate <a href="Integral_(mathematics)" class="mw-redirect" title="Integral (mathematics)">integral</a> <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \textstyle \int _{a}^{b}}">

</mrow>

</mrow>

</msubsup>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle \textstyle \int _{a}^{b}}</annotation>

</semantics>

</math><img src="./b53a1a66659263a9b99efd1f4347d19417b9ce40.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.005ex; width:2.452ex; height:3.676ex;" alt="{\displaystyle \textstyle \int _{a}^{b}}" loading="lazy"> f (x) dx of a given real-valued <a href="Function_(mathematics)" title="Function (mathematics)">function</a> f over a given interval [a,b] of the <a href="Real_number" title="Real number">real line</a>. The <a href="Numerical_method" title="Numerical method">numerical method</a> used is the <a href="Trapezium_rule" class="mw-redirect" title="Trapezium rule">trapezium rule</a> with a given number n of steps; the real numbers are approximated by floating-point numbers.

<pre>procedure Intg(f, a, b, n):

float t, x, s; integer i

if b = a then return 0

x ← a; s ← f(a) / 2;

for i from 1 to n−1 do

t ← i/(n+1); x ← (1−t) * a + t * b;

s ← s + f(x)

s ← f(b) / 2

return (b − a) * s / n

</pre>

<div class="mw-heading mw-heading3"><h3 id="Integrating_over_a_disk">Integrating over a disk</h3></div>

Consider now the problem of integrating a given function <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle g}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle g}</annotation>

</semantics>

</math><img src="./d3556280e66fe2c0d0140df20935a6f057381d77.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:1.116ex; height:2.009ex;" alt="{\displaystyle g}" loading="lazy">, with two arguments, over a disk <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle D}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle D}</annotation>

</semantics>

</math><img src="./f34a0c600395e5d4345287e21fb26efd386990e6.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.924ex; height:2.176ex;" alt="{\displaystyle D}" loading="lazy"> with given center (<math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle xc,yc}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle xc,yc}</annotation>

</semantics>

</math><img src="./71b6c4db6efaefa693ff8357c47551165d5f6bcd.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:5.533ex; height:2.009ex;" alt="{\displaystyle xc,yc}" loading="lazy">) and given radius <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle R}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle R}</annotation>

</semantics>

<msub>

</mrow>

</msub>

</mrow>

</mrow>

</mrow>

</mrow>

</msubsup>

<mrow>

<mrow>

</mrow>

</mrow>

</msubsup>

</mrow>

</mrow>

</mrow>

</mrow>

</mrow>

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle \int \!\int _{D}g(x,y)\,\mathrm {d} x\,\mathrm {d} y=\int _{0}^{R}z\left(\int _{0}^{2\pi }g({\mathit {xc}}+z\cos t,{\mathit {yc}}+z\sin t)\,\mathrm {d} t\right)\,\mathrm {d} z}</annotation>

</semantics>

</math><img src="./36302270940ead35c1f046d53e9b45550e90788a.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -2.505ex; width:65.961ex; height:6.343ex;" alt="{\displaystyle \int \!\int _{D}g(x,y)\,\mathrm {d} x\,\mathrm {d} y=\int _{0}^{R}z\left(\int _{0}^{2\pi }g({\mathit {xc}}+z\cos t,{\mathit {yc}}+z\sin t)\,\mathrm {d} t\right)\,\mathrm {d} z}" loading="lazy"></dd></dl>

The following code implements the <a href="Sides_of_an_equation" title="Sides of an equation">right-hand-side formula</a>:

<pre>procedure DiskIntg(g, xc, yc, R, n)

procedure gring(z):

procedure gpolar(t):

float x, y

x ← xc + z * cos(t)

y ← yc + z * sin(t)

return g(x, y)

integer m ← round(n*z/R)

return z * Intg(gpolar, 0, 2*π, m)

return Intg(gring, 0, R, n)

</pre>

This code uses the integration procedure Intg in two levels. The outer level (last line) uses Intg to compute the integral of <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle gring(z)}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle gring(z)}</annotation>

</semantics>

</math><img src="./bf7ec7b065e42d57d08f722b7f437f71de2e8379.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:8.375ex; height:2.843ex;" alt="{\displaystyle gring(z)}" loading="lazy"> for <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle z}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle z}</annotation>

</semantics>

</math><img src="./bf368e72c009decd9b6686ee84a375632e11de98.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.088ex; height:1.676ex;" alt="{\displaystyle z}" loading="lazy"> varying from 0 to <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle R}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle R}</annotation>

</semantics>

</math><img src="./4b0bfb3769bf24d80e15374dc37b0441e2616e33.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.764ex; height:2.176ex;" alt="{\displaystyle R}" loading="lazy">. The inner level (next-to-last line) defines <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle gring(z)}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle gring(z)}</annotation>

</semantics>

</math><img src="./bf7ec7b065e42d57d08f722b7f437f71de2e8379.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:8.375ex; height:2.843ex;" alt="{\displaystyle gring(z)}" loading="lazy"> as being the <a href="Line_integral" title="Line integral">line integral</a> of <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle g(x,y)}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle g(x,y)}</annotation>

</semantics>

</math><img src="./bf358a54b0375e22ae5f3ab2c3e1a22c0c87e11c.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:6.444ex; height:2.843ex;" alt="{\displaystyle g(x,y)}" loading="lazy"> over the circle with center <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle (xc,yc)}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle (xc,yc)}</annotation>

</semantics>

</math><img src="./4f9380cd74ca531ea9fc771057723309bc1386d9.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:7.342ex; height:2.843ex;" alt="{\displaystyle (xc,yc)}" loading="lazy"> and radius <math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle z}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle z}</annotation>

</semantics>

<div class="mw-heading mw-heading2"><h2 id="History">History</h2></div>

Procedural parameters were invented before the age of electronic computers, by <a href="Mathematician" title="Mathematician">mathematician</a> <a href="Alonzo_Church" title="Alonzo Church">Alonzo Church</a>, as part of his <a href="Lambda_calculus" title="Lambda calculus">lambda calculus</a> model of computation.

Procedural parameters as a programming language feature were introduced by <a href="ALGOL_60_programming_language" class="mw-redirect" title="ALGOL 60 programming language">ALGOL 60</a>. In fact, ALGOL 60 had a powerful "<a href="Call_by_name" class="mw-redirect" title="Call by name">call by name</a>" parameter-passing mechanism that could simplify some uses of procedural parameters; see <a href="Jensen's_Device" class="mw-redirect" title="Jensen's Device">Jensen's Device</a>.

Procedural parameters were an essential feature of the <a href="LISP_programming_language" class="mw-redirect" title="LISP programming language">LISP programming language</a>, which also introduced the concept of function closure or <a href="Funarg" class="mw-redirect" title="Funarg">funarg</a>. The <a href="C_(programming_language)" title="C (programming language)">C programming language</a> allows <a href="Function_pointers" class="mw-redirect" title="Function pointers">function pointers</a> to be passed as parameters, which accomplish the same end, and are often used as <a href="Callbacks" class="mw-redirect" title="Callbacks">callbacks</a> in <a href="Event-driven_programming" title="Event-driven programming">event-driven programming</a> and as error handlers. However, only a few modern C compilers allow nested function definitions, so that its other uses are relatively uncommon. Procedural parameters were provided also in Pascal, together with nested procedure definitions; however, since standard Pascal did not allow separate compilation, the feature was little used in that language, too.

<ul><li><a href="Function_pointer" title="Function pointer">Function pointer</a></li>

<li><a href="Functional_programming" title="Functional programming">Functional programming</a></li>

<li><a href="Funarg_problem" title="Funarg problem">Funarg problem</a></li>

<li><a href="Design_patterns_(computer_science)" class="mw-redirect" title="Design patterns (computer science)">Design patterns (computer science)</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

</div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-05-14" href="https://en.wikipedia.org/wiki/?title=Procedural_parameter&oldid=1290309154">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>